import java.io.*;
import java.util.Scanner;

public class TestDome3 {
    public static void main(String[] args) throws IOException {
        // 1. 输入要扫描的文件路径
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要扫描的路径: ");
        String rootDirPath = scanner.next();
        System.out.println("请输入要查询的关键词: ");
        String word1 = scanner.next();
        File rootDir1 = new File(rootDirPath);
        if (!rootDir1.isDirectory()) {
            System.out.println("输入的路径非法!");
            return;
        }
        // 2. 递归的进行遍历
        scanDir1(rootDir1, word1);
    }

    private static void scanDir1(File rootDir1, String word1) throws IOException {
        // 1. 先列出 rootDir 中都有哪些内容
        File[] files = rootDir1.listFiles();
        if (files == null) {
            return;
        }
        // 2. 遍历每个元素, 针对普通文件和目录分别进行处理.
        for (File f1 : files) {
            if (f1.isFile()) {
                // 针对文件进行内容查找
                if (containsWord(f1, word1)) {
                    System.out.println(f1.getCanonicalPath());
                }
            } else if (f1.isDirectory()) {
                // 针对目录进行递归
                scanDir(f1, word1);
            }
        }
    }

    private static boolean containsWord(File f, String word) {
        // 写代码, 慎重使用缩写!!! 缩写的可读性会比较差. (一些业界常见缩写, 可以用, 不要随便滥用)
        StringBuilder stringBuilder = new StringBuilder();
        // 把 f 中的内容都读出来, 放到一个 StringBuilder 中
        try (Reader reader = new FileReader(f)) {
            char[] buffer = new char[1024];
            while (true) {
                int len = reader.read(buffer);
                if (len == -1) {
                    break;
                }
                // 把这一段读到的结果, 放到 StringBuilder 中
                stringBuilder.append(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // indexOf 返回的是子串的下标. 如果 word 在 stringBuilder 中不存在, 则返回下标为 -1
        return stringBuilder.indexOf(word) != -1;
    }
    public static void main12(String[] args) {
        // 1. 输入两个路径
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要拷贝的源路径: ");
        String src = scanner.next();
        System.out.println("请输入要拷贝的目标路径: ");
        String dest = scanner.next();
        File srcFile = new File(src);
        if (!srcFile.isFile()) {
            System.out.println("输入的源路径不正确!");
            return;
        }
        // 此处不太需要检查目标文件是否存在. OutputStream 写文件的时候能够自动创建不存在的文件.
        // 2. 读取源文件, 拷贝到目标文件中
        try (InputStream inputStream = new FileInputStream(src)) {
            try (OutputStream outputStream = new FileOutputStream(dest)) {
                // 把 inputStream 中的数据读出来, 写入到 outputStream 中
                byte[] buffer = new byte[1024];
                while (true) {
                    int len = inputStream.read(buffer);
                    if (len == -1) {
                        // 读取完毕
                        break;
                    }
                    // 写入的时候, 不能把整个 buffer 都写进去. 毕竟 buffer 可能是只有一部分才是有效数据.
                    outputStream.write(buffer, 0, len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main11(String[] args) {
        //案例1，实现查找文件并删除
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入扫描的路径：");
        String rootDirPath = scanner.next();
        System.out.println("请输入要删除的文件名：");
        String toDeleteName = scanner.next();
        File file = new File(rootDirPath);
        if(! file.isDirectory()){
            System.out.println("输入的扫描路径有误！");
            return;
        }
        //2.遍历目录，把指定目录中的所有文件和子目录都遍历一遍，从而找到要删除的文件
        //通过这个方法来实现递归遍历并删除的操作
        scanDir(file,toDeleteName);
    }

    private static void scanDir(File file, String toDeleteName){
        //1.先列出file中都有那些内容
        File[] files = file.listFiles();
        if(files == null){
            //file时一个空目录
            return;
        }
        //2.遍历当前列出的这些内容，如果是普通文件，就检测文件名是否要删除的文件
        //如果是目录，就递归的进行遍历
        for (File f : files) {
            if(f.isFile()){
                //普通文件的情况
                if(f.getName().contains(toDeleteName)){
                    //不要求名字完全一样，只要文件名包含了关键字即可删除
                    //进行删除操作
                    deleteFile(f);
                }
            }else if(f.isDirectory()){
                //目录就递归的进行遍历
                scanDir(f,toDeleteName);
            }
        }
    }

    private static void deleteFile(File f){
        try {
            System.out.println(f.getCanonicalPath() + " 确认要删除吗? (Y/n)");
            Scanner scanner = new Scanner(System.in);
            String choice = scanner.next();
            if (choice.equals("Y") || choice.equals("y")) {
                f.delete();
                System.out.println("文件删除成功!");
            } else {
                System.out.println("文件取消删除!");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main10(String[] args) {
        //按照字符来读
        try(Reader reader = new FileReader("D:\\test")){
            while(true){
                char[] array = new char[1024];
                int len = reader.read(array);
                if(len == -1){
                    break;
                }
                for (int i = 0; i < len; i++) {
                    System.out.println(array[i]);
                }
                //String s = new String(array, 0, len);
                //System.out.println(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //按照字符来写
        try (Writer writer = new FileWriter("D:\\test")){
            writer.write("xyz");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main9(String[] args) {
        //使用字节流，写文件的案例
        try(OutputStream outputStream = new FileOutputStream("D:\\test")){
            /*outputStream.write(98);
            outputStream.write(99);
            outputStream.write(100);
*/
            byte [] buffer = new byte[]{98,99,100};
            outputStream.write(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main8(String[] args) {
        try(InputStream inputStream = new FileInputStream("D:\\test")){
            while(true){
                byte [] buffer = new byte[1024];
                int len = inputStream.read();
                if(len == -1){
                    break;
                }
                for (int i = 0; i < len; i++) {
                    System.out.println(buffer[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main7(String[] args) {
        try(InputStream inputStream = new FileInputStream("D:\\test")){
            while(true){
                int b = inputStream.read();
                if(b == -1){
                    break;
                }
                System.out.println(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main6(String[] args) {
        //构造方法中需要指定打开文件的路径
        //此处的路径可以时绝对路径，也可以时相对路径，也可以时file
        InputStream inputStream = null;
        try{
            //1.创建对象，同时也是再打开文件
            inputStream = new FileInputStream("D:\\test.txt");
            //2.尝试一个一个字节的读，把整个文件都读完
            while(true){
                int b = inputStream.read();
                if(b == -1){
                    break;//读到了末尾
                }
                System.out.println(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //3.读完之后要记得关闭文件，释放资源
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main5(String[] args) {
        File f = new File("./aaa/bbb");
        f.mkdirs();
        f.delete();
    }
    public static void main4(String[] args) {
        File f = new File("D:\\JavaIDEA\\src");
        f.delete();
    }
    public static void main3(String[] args) throws IOException {
        File f = new File("D:\\JavaIDEA\\src");
        System.out.println(f.exists());
        System.out.println("创建文件");
        f.createNewFile();
        System.out.println("创建文件结束");
        System.out.println(f.exists());

    }
    public static void main2(String[] args) {
        File f = new File("D:\\JavaIDEA\\src");
        System.out.println(f.exists());
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
    }
    public static void main1(String[] args) throws IOException {
        File f = new File("D:\\JavaIDEA\\src");
        System.out.println(f.getParent());//获取文件的父目录
        System.out.println(f.getName());//获取文件名
        System.out.println(f.getPath());//获取文件路径
        System.out.println(f.getAbsolutePath());//获取绝对路径
        System.out.println(f.getCanonicalPath());//获取相对路径

        System.out.println("=============");

        File f2 = new File("./JavaIDEA/src");
        System.out.println(f2.getParent());
        System.out.println(f2.getName());
        System.out.println(f2.getPath());
        System.out.println(f2.getAbsolutePath());
        System.out.println(f2.getCanonicalPath());
    }
}
